{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Together AI models with E2B Code interpreter        \n",
    "\n",
    "This Ai data analyst is using a coding LLM of your choice by Together AI. It has code execution capabilities, powered by the open-source [Code Interpreter SDK](https://github.com/e2b-dev/code-interpreter) by [E2B](https://e2b.dev/docs). The AI analyst \n",
    "\n",
    "The E2B's Code Interpreter SDK quickly creates a secure cloud sandbox powered by [Firecracker](https://github.com/firecracker-microvm/firecracker).Inside this sandbox is a running Jupyter server that the LLM can use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OLxqUGV5_wnv",
    "outputId": "a14f6c98-6a10-4583-c398-be1672ed0d5a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: together==1.2.1 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from -r requirements.txt (line 1)) (1.2.1)\n",
      "Requirement already satisfied: e2b-code-interpreter==0.0.10 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from -r requirements.txt (line 2)) (0.0.10)\n",
      "Requirement already satisfied: python-dotenv==1.0.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from -r requirements.txt (line 3)) (1.0.0)\n",
      "Requirement already satisfied: aiohttp<4.0.0,>=3.9.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (3.9.5)\n",
      "Requirement already satisfied: click<9.0.0,>=8.1.7 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (8.1.7)\n",
      "Requirement already satisfied: eval-type-backport<0.3.0,>=0.1.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (0.2.0)\n",
      "Requirement already satisfied: filelock<4.0.0,>=3.13.1 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (3.15.4)\n",
      "Requirement already satisfied: numpy>=1.23.5 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (1.26.4)\n",
      "Requirement already satisfied: pillow<11.0.0,>=10.3.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (10.4.0)\n",
      "Requirement already satisfied: pyarrow>=10.0.1 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (14.0.1)\n",
      "Requirement already satisfied: pydantic<3.0.0,>=2.6.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (2.7.1)\n",
      "Requirement already satisfied: requests<3.0.0,>=2.31.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (2.31.0)\n",
      "Requirement already satisfied: tabulate<0.10.0,>=0.9.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (0.9.0)\n",
      "Requirement already satisfied: tqdm<5.0.0,>=4.66.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (4.66.2)\n",
      "Requirement already satisfied: typer<0.13,>=0.9 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from together==1.2.1->-r requirements.txt (line 1)) (0.9.0)\n",
      "Requirement already satisfied: e2b>=0.17.1 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b-code-interpreter==0.0.10->-r requirements.txt (line 2)) (0.17.1)\n",
      "Requirement already satisfied: websocket-client<2.0.0,>=1.7.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b-code-interpreter==0.0.10->-r requirements.txt (line 2)) (1.7.0)\n",
      "Requirement already satisfied: aiosignal>=1.1.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp<4.0.0,>=3.9.3->together==1.2.1->-r requirements.txt (line 1)) (1.3.1)\n",
      "Requirement already satisfied: attrs>=17.3.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp<4.0.0,>=3.9.3->together==1.2.1->-r requirements.txt (line 1)) (23.1.0)\n",
      "Requirement already satisfied: frozenlist>=1.1.1 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp<4.0.0,>=3.9.3->together==1.2.1->-r requirements.txt (line 1)) (1.4.0)\n",
      "Requirement already satisfied: multidict<7.0,>=4.5 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp<4.0.0,>=3.9.3->together==1.2.1->-r requirements.txt (line 1)) (6.0.4)\n",
      "Requirement already satisfied: yarl<2.0,>=1.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp<4.0.0,>=3.9.3->together==1.2.1->-r requirements.txt (line 1)) (1.9.2)\n",
      "Requirement already satisfied: aenum>=3.1.11 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b-code-interpreter==0.0.10->-r requirements.txt (line 2)) (3.1.15)\n",
      "Requirement already satisfied: jsonrpcclient>=4.0.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b-code-interpreter==0.0.10->-r requirements.txt (line 2)) (4.0.3)\n",
      "Requirement already satisfied: python-dateutil>=2.8.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b-code-interpreter==0.0.10->-r requirements.txt (line 2)) (2.8.2)\n",
      "Requirement already satisfied: typing-extensions>=4.8.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b-code-interpreter==0.0.10->-r requirements.txt (line 2)) (4.9.0)\n",
      "Requirement already satisfied: urllib3>=1.25.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b-code-interpreter==0.0.10->-r requirements.txt (line 2)) (2.2.1)\n",
      "Requirement already satisfied: websockets>=11.0.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b-code-interpreter==0.0.10->-r requirements.txt (line 2)) (11.0.3)\n",
      "Requirement already satisfied: annotated-types>=0.4.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from pydantic<3.0.0,>=2.6.3->together==1.2.1->-r requirements.txt (line 1)) (0.5.0)\n",
      "Requirement already satisfied: pydantic-core==2.18.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from pydantic<3.0.0,>=2.6.3->together==1.2.1->-r requirements.txt (line 1)) (2.18.2)\n",
      "Requirement already satisfied: charset-normalizer<4,>=2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from requests<3.0.0,>=2.31.0->together==1.2.1->-r requirements.txt (line 1)) (3.3.2)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from requests<3.0.0,>=2.31.0->together==1.2.1->-r requirements.txt (line 1)) (3.6)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from requests<3.0.0,>=2.31.0->together==1.2.1->-r requirements.txt (line 1)) (2024.2.2)\n",
      "Requirement already satisfied: six>=1.5 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from python-dateutil>=2.8.2->e2b>=0.17.1->e2b-code-interpreter==0.0.10->-r requirements.txt (line 2)) (1.16.0)\n",
      "\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.1.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.2\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install together==1.3.1 e2b_code_interpreter==1.0.0 python-dotenv==1.0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "NYAAAS_kFD87"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from dotenv import load_dotenv\n",
    "import os\n",
    "import json\n",
    "import re\n",
    "from together import Together\n",
    "from e2b_code_interpreter import Sandbox\n",
    "\n",
    "load_dotenv()\n",
    "\n",
    "# TODO: Get your Together AI API key from https://api.together.xyz/settings/api-keys\n",
    "TOGETHER_API_KEY = os.getenv(\"TOGETHER_API_KEY\")\n",
    "\n",
    "# TODO: Get your E2B API key from https://e2b.dev/docs\n",
    "E2B_API_KEY = os.getenv(\"E2B_API_KEY\")\n",
    "\n",
    "# Choose from the codegen models:\n",
    "\n",
    "MODEL_NAME = \"meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo\"\n",
    "# MODEL_NAME = \"meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo\"\n",
    "# MODEL_NAME = \"meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo\"\n",
    "# MODEL_NAME = \"codellama/CodeLlama-70b-Instruct-hf\"\n",
    "# MODEL_NAME = \"deepseek-ai/deepseek-coder-33b-instruct\"\n",
    "# MODEL_NAME = \"Qwen/Qwen2-72B-Instruct\"\n",
    "# See the complete list of Together AI models here: https://api.together.ai/models.\n",
    "\n",
    "SYSTEM_PROMPT = \"\"\"You're a Python data scientist. You are given tasks to complete and you run Python code to solve them.\n",
    "\n",
    "Information about the csv dataset:\n",
    "- It's in the `/home/user/data.csv` file\n",
    "- The CSV file is using , as the delimiter\n",
    "- It has the following columns (examples included):\n",
    "    - country: \"Argentina\", \"Australia\"\n",
    "    - Region: \"SouthAmerica\", \"Oceania\"\n",
    "    - Surface area (km2): for example, 2780400\n",
    "    - Population in thousands (2017): for example, 44271\n",
    "    - Population density (per km2, 2017): for example, 16.2\n",
    "    - Sex ratio (m per 100 f, 2017): for example, 95.9\n",
    "    - GDP: Gross domestic product (million current US$): for example, 632343\n",
    "    - GDP growth rate (annual %, const. 2005 prices): for example, 2.4\n",
    "    - GDP per capita (current US$): for example, 14564.5\n",
    "    - Economy: Agriculture (% of GVA): for example, 10.0\n",
    "    - Economy: Industry (% of GVA): for example, 28.1\n",
    "    - Economy: Services and other activity (% of GVA): for example, 61.9\n",
    "    - Employment: Agriculture (% of employed): for example, 4.8\n",
    "    - Employment: Industry (% of employed): for example, 20.6\n",
    "    - Employment: Services (% of employed): for example, 74.7\n",
    "    - Unemployment (% of labour force): for example, 8.5\n",
    "    - Employment: Female (% of employed): for example, 43.7\n",
    "    - Employment: Male (% of employed): for example, 56.3\n",
    "    - Labour force participation (female %): for example, 48.5\n",
    "    - Labour force participation (male %): for example, 71.1\n",
    "    - International trade: Imports (million US$): for example, 59253\n",
    "    - International trade: Exports (million US$): for example, 57802\n",
    "    - International trade: Balance (million US$): for example, -1451\n",
    "    - Education: Government expenditure (% of GDP): for example, 5.3\n",
    "    - Health: Total expenditure (% of GDP): for example, 8.1\n",
    "    - Health: Government expenditure (% of total health expenditure): for example, 69.2\n",
    "    - Health: Private expenditure (% of total health expenditure): for example, 30.8\n",
    "    - Health: Out-of-pocket expenditure (% of total health expenditure): for example, 20.2\n",
    "    - Health: External health expenditure (% of total health expenditure): for example, 0.2\n",
    "    - Education: Primary gross enrollment ratio (f/m per 100 pop): for example, 111.5/107.6\n",
    "    - Education: Secondary gross enrollment ratio (f/m per 100 pop): for example, 104.7/98.9\n",
    "    - Education: Tertiary gross enrollment ratio (f/m per 100 pop): for example, 90.5/72.3\n",
    "    - Education: Mean years of schooling (female): for example, 10.4\n",
    "    - Education: Mean years of schooling (male): for example, 9.7\n",
    "    - Urban population (% of total population): for example, 91.7\n",
    "    - Population growth rate (annual %): for example, 0.9\n",
    "    - Fertility rate (births per woman): for example, 2.3\n",
    "    - Infant mortality rate (per 1,000 live births): for example, 8.9\n",
    "    - Life expectancy at birth, female (years): for example, 79.7\n",
    "    - Life expectancy at birth, male (years): for example, 72.9\n",
    "    - Life expectancy at birth, total (years): for example, 76.4\n",
    "    - Military expenditure (% of GDP): for example, 0.9\n",
    "    - Population, female: for example, 22572521\n",
    "    - Population, male: for example, 21472290\n",
    "    - Tax revenue (% of GDP): for example, 11.0\n",
    "    - Taxes on income, profits and capital gains (% of revenue): for example, 12.9\n",
    "    - Urban population (% of total population): for example, 91.7\n",
    "\n",
    "Generally, you follow these rules:\n",
    "- ALWAYS FORMAT YOUR RESPONSE IN MARKDOWN\n",
    "- ALWAYS RESPOND ONLY WITH CODE IN CODE BLOCK LIKE THIS:\n",
    "```python\n",
    "{code}\n",
    "```\n",
    "- the Python code runs in jupyter notebook.\n",
    "- every time you generate Python, the code is executed in a separate cell. it's okay to make multiple calls to `execute_python`.\n",
    "- display visualizations using matplotlib or any other visualization library directly in the notebook. don't worry about saving the visualizations to a file.\n",
    "- you have access to the internet and can make api requests.\n",
    "- you also have access to the filesystem and can read/write files.\n",
    "- you can install any pip package (if it exists) if you need to be running `!pip install {package}`. The usual packages for data analysis are already preinstalled though.\n",
    "- you can run any Python code you want, everything is running in a secure sandbox environment\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "BpiwOkTqEeBh"
   },
   "outputs": [],
   "source": [
    "def code_interpret(e2b_code_interpreter, code):\n",
    "    print(\"Running code interpreter...\")\n",
    "    exec = e2b_code_interpreter.run_code(code,\n",
    "    on_stderr=lambda stderr: print(\"[Code Interpreter]\", stderr),\n",
    "    on_stdout=lambda stdout: print(\"[Code Interpreter]\", stdout))\n",
    "\n",
    "    if exec.error:\n",
    "        print(\"[Code Interpreter ERROR]\", exec.error)\n",
    "    else:\n",
    "        return exec.results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "IsLjFlRW_TAR"
   },
   "outputs": [],
   "source": [
    "client = Together(api_key=TOGETHER_API_KEY)\n",
    "\n",
    "pattern = re.compile(\n",
    "    r\"```python\\n(.*?)\\n```\", re.DOTALL\n",
    ")  # Match everything in between ```python and ```\n",
    "\n",
    "\n",
    "def match_code_blocks(llm_response):\n",
    "    match = pattern.search(llm_response)\n",
    "    if match:\n",
    "        code = match.group(1)\n",
    "        print(code)\n",
    "        return code\n",
    "    return \"\"\n",
    "\n",
    "\n",
    "def chat_with_llm(e2b_code_interpreter, user_message):\n",
    "    print(f\"\\n{'='*50}\\nUser message: {user_message}\\n{'='*50}\")\n",
    "\n",
    "    messages = [\n",
    "        {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n",
    "        {\"role\": \"user\", \"content\": user_message},\n",
    "    ]\n",
    "\n",
    "    response = client.chat.completions.create(\n",
    "        model=MODEL_NAME,\n",
    "        messages=messages,\n",
    "    )\n",
    "\n",
    "    response_message = response.choices[0].message\n",
    "    python_code = match_code_blocks(response_message.content)\n",
    "    if python_code != \"\":\n",
    "        code_interpreter_results = code_interpret(e2b_code_interpreter, python_code)\n",
    "        return code_interpreter_results\n",
    "    else:\n",
    "        print(f\"Failed to match any Python code in model's response {response_message}\")\n",
    "        return []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def upload_dataset(code_interpreter):\n",
    "    print(\"Uploading dataset to Code Interpreter sandbox...\")\n",
    "    dataset_path = \"./data.csv\"\n",
    "\n",
    "    if not os.path.exists(dataset_path):\n",
    "        raise FileNotFoundError(\"Dataset file not found\")\n",
    "\n",
    "    try:\n",
    "        with open(dataset_path, \"rb\") as f:\n",
    "            code_interpreter.files.write(dataset_path, f)\n",
    "\n",
    "        print(\"Uploaded at\", dataset_path)\n",
    "        return dataset_path\n",
    "    except Exception as error:\n",
    "        print(\"Error during file upload:\", error)\n",
    "        raise error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "wKSWobclENIq",
    "outputId": "65ab42e7-6559-4e36-fb5a-d8e57fc455c0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uploading dataset to Code Interpreter sandbox...\n",
      "Uploaded at /home/user/data.csv\n",
      "\n",
      "==================================================\n",
      "User message: Make a chart showing linear regression of the relationship between GDP per capita and life expectancy from the data. Filter out any missing values or values in wrong format.\n",
      "==================================================\n",
      "import pandas as pd\n",
      "import matplotlib.pyplot as plt\n",
      "from sklearn.linear_model import LinearRegression\n",
      "import numpy as np\n",
      "\n",
      "# Load the data\n",
      "df = pd.read_csv('/home/user/data.csv')\n",
      "\n",
      "# Filter out missing values\n",
      "df = df.dropna(subset=['GDP per capita (current US$)', 'Life expectancy at birth, total (years)'])\n",
      "\n",
      "# Ensure correct data types\n",
      "df['GDP per capita (current US$)'] = pd.to_numeric(df['GDP per capita (current US$)'], errors='coerce')\n",
      "df['Life expectancy at birth, total (years)'] = pd.to_numeric(df['Life expectancy at birth, total (years)'], errors='coerce')\n",
      "\n",
      "# Drop rows with non-numeric values\n",
      "df = df.dropna(subset=['GDP per capita (current US$)', 'Life expectancy at birth, total (years)'])\n",
      "\n",
      "# Perform linear regression\n",
      "X = df[['GDP per capita (current US$)']]\n",
      "y = df['Life expectancy at birth, total (years)']\n",
      "model = LinearRegression()\n",
      "model.fit(X, y)\n",
      "\n",
      "# Predict life expectancy\n",
      "y_pred = model.predict(X)\n",
      "\n",
      "# Plot the data\n",
      "plt.scatter(X, y, label='Data')\n",
      "plt.plot(X, y_pred, color='red', label='Linear Regression')\n",
      "plt.xlabel('GDP per capita (current US$)')\n",
      "plt.ylabel('Life expectancy at birth, total (years)')\n",
      "plt.title('Linear Regression of GDP per capita vs Life Expectancy')\n",
      "plt.legend()\n",
      "plt.show()\n",
      "Running code interpreter...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Result(<Figure size 640x480 with 1 Axes>)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with Sandbox(api_key=E2B_API_KEY) as code_interpreter:\n",
    "    # Upload the dataset to the code interpreter sandbox\n",
    "    upload_dataset(code_interpreter)\n",
    "\n",
    "    code_results = chat_with_llm(\n",
    "        code_interpreter,\n",
    "        \"Make a chart showing linear regression of the relationship between GDP per capita and life expectancy from the data. Filter out any missing values or values in wrong format.\",\n",
    "    )\n",
    "    if code_results:\n",
    "        first_result = code_results[0]\n",
    "    else:\n",
    "        raise Exception(\"No code interpreter results\")\n",
    "\n",
    "\n",
    "# This will render the image\n",
    "# You can also access the data directly\n",
    "# first_result.png\n",
    "# first_result.jpg\n",
    "# first_result.pdf\n",
    "# ...\n",
    "first_result"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
